package com.demo.java.OD51_100.OD54;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;

/**
 * @author bug菌
 * @Source 公众号：猿圈奇妙屋
 * @des： 【最多等和不相交连续子序列】问题
 * @url： https://blog.csdn.net/weixin_43970743/article/details/145596898
 */
public class OdMain {
    public static void main(String[] args) {
        try {
            Scanner s = new Scanner(System.in);
            int length = s.nextInt();  // 输入序列长度
            s.nextLine();  // 读取换行符
            int[] values = new int[length];

            // 输入序列
            for (int i = 0; i < length; ++i) {
                values[i] = s.nextInt();
            }

            int maxValues = 0;  // 最大不相交子序列的数量
            int[] dp = new int[length];

            // 动态规划数组初始化
            System.arraycopy(values, 0, dp, 0, length);
            Map<Integer, Integer> sumCountMap = new HashMap<>();  // 存储每个子序列和出现的次数
            Map<Integer, HashSet<Integer>> sumPosMap = new HashMap<>();  // 存储每个和对应的位置集合

            // 遍历所有可能的子序列
            for (int i = 0; i < length; ++i) {
                for (int j = 0; j + i < length; ++j) {
                    if (i > 0) {
                        dp[j] = dp[j] + values[j + i];
                    }
                    int sum = dp[j];  // 当前子序列的和

                    // 初始化哈希表
                    if (!sumCountMap.containsKey(sum)) {
                        sumCountMap.put(sum, 0);
                        sumPosMap.put(sum, new HashSet<>());
                    }

                    boolean exists = false;
                    HashSet<Integer> possSet = sumPosMap.get(sum);

                    // 检查当前子序列是否与之前的子序列重叠
                    for (int k = j; k <= j + i; k++) {
                        if (exists = possSet.contains(k)) {
                            break;
                        }
                    }

                    // 如果不重叠，更新哈希表和最大值
                    if (!exists) {
                        int newSum = sumCountMap.get(sum) + 1;
                        sumCountMap.put(sum, newSum);
                        maxValues = Math.max(maxValues, newSum);  // 更新最大值
                        for (int k = j; k <= j + i; ++k) {
                            possSet.add(k);  // 将当前子序列的位置添加到哈希表
                        }
                        sumPosMap.put(sum, possSet);  // 更新位置集合
                    }
                }
            }

            // 输出最终结果
            System.out.println(maxValues);

        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("input error");
        }
    }
}